
#include "Math.h"

#include <math.h>

using namespace Riccsson::System;

const double Math::E =2.71828182845904523536;
const double Math::PI = 3.14159265358979323846;


decimal Math::Abs(decimal value)
{
	//return (value < 0) ? - value : value;
	throw;
}

double Math::Abs(double value)
{
	return (value < 0) ? - value : value;
}

float Math::Abs(float value)
{
	return (value < 0) ? - value : value;
}

int Math::Abs(int value)
{
	return (value < 0) ? - value : value;
}

long Math::Abs(long value)
{
	return (value < 0) ? - value : value;
}

long long Math::Abs(long long value)
{
	return (value < 0) ? - value : value;
}

sbyte Math::Abs(sbyte value)
{
	return (sbyte)((value < 0) ? - value : value);
}

short Math::Abs(short value)
{
	return (short)abs(value);
}

double Math::Acos(double d)
{
	return acos(d);
}

double Math::Asin(double d)
{
	return asin(d);
}

double Math::Atan(double d)
{
	return atan(d);
}

double Math::Atan2(double y, double x)
{
	return atan2(y, x);
}

long Math::BigMul(int a, int b)
{
	throw;
}

decimal Math::Ceiling(decimal d)
{
	throw;
}

double Math::Ceiling(double a)
{
	return ceil(a);
}

double Math::Cos(double d)
{
	return cos(d);
}

double Math::Cosh(double value)
{
	return cosh(value);
}

int Math::DivRem(int a, int b, int out result)
{
	throw;
}


long Math::DivRem(long a, long b, long out result)
{
	throw;
}


double Math::Exp(double d)
{
	return exp(d);
}


decimal Math::Floor(decimal d)
{
	throw;
}


double Math::Floor(double d)
{
	return floor(d);
}


double Math::IEEERemainder(double x, double y)
{
	throw;
}


double Math::Log(double d)
{
	return log(d);
}


double Log(double a, double newBase)
{
	throw;
}


double Math::Log10(double d)
{
	return log10(d);
}


byte Math::Max(byte val1, byte val2)
{
	return (val1 > val2) ? val1 : val2;
}


decimal Math::Max(decimal val1, decimal val2)
{
	throw;
}


double Math::Max(double val1, double val2)
{
	return (val1 > val2) ? val1 : val2;
}


float Math::Max(float val1, float val2)
{
	return (val1 > val2) ? val1 : val2;
}


int Math::Max(int val1, int val2)
{
	return (val1 > val2) ? val1 : val2;
}


long Math::Max(long val1, long val2)
{
	return (val1 > val2) ? val1 : val2;
}


sbyte Math::Max(sbyte val1, sbyte val2)
{
	return (val1 > val2) ? val1 : val2;
}


short Math::Max(short val1, short val2)
{
	return (val1 > val2) ? val1 : val2;
}


uint Math::Max(uint val1, uint val2)
{
	return (val1 > val2) ? val1 : val2;
}


ulong Math::Max(ulong val1, ulong val2)
{
	return (val1 > val2) ? val1 : val2;
}


ushort Math::Max(ushort val1, ushort val2)
{
	return (val1 > val2) ? val1 : val2;
}


byte Math::Min(byte val1, byte val2)
{
	return (val1 < val2) ? val1 : val2;
}


decimal Math::Min(decimal val1, decimal val2)
{
	throw;
}


double Math::Min(double val1, double val2)
{
	return (val1 < val2) ? val1 : val2;
}


float Math::Min(float val1, float val2)
{
	return (val1 < val2) ? val1 : val2;
}


int Math::Min(int val1, int val2)
{
	return (val1 < val2) ? val1 : val2;
}


long Math::Min(long val1, long val2)
{
	return (val1 < val2) ? val1 : val2;
}


sbyte Math::Min(sbyte val1, sbyte val2)
{
	return (sbyte)((val1 < val2) ? val1 : val2);
}


short Math::Min(short val1, short val2)
{
	return (val1 < val2) ? val1 : val2;
}


uint Math::Min(uint val1, uint val2)
{
	return (val1 < val2) ? val1 : val2;
}


ulong Math::Min(ulong val1, ulong val2)
{
	return (val1 < val2) ? val1 : val2;
}


ushort Math::Min(ushort val1, ushort val2)
{
	return (val1 < val2) ? val1 : val2;
}


double Math::Pow(double x, double y)
{
	return pow(x, y);
}


decimal Math::Round(decimal d)
{
	throw;
}


double Math::Round(double a)
{
	return (int)(a + 0.5);
}


decimal Math::Round(decimal d, int decimals)
{
	throw;
}


decimal Math::Round(decimal d, MidpointRounding mode)
{
	throw;
}


double Math::Round(double value, int digits)
{
	throw;
}


double Math::Round(double value, MidpointRounding mode)
{
	throw;
}


decimal Math::Round(decimal d, int decimals, MidpointRounding mode)
{
	throw;
}


double Math::Round(double value, int digits, MidpointRounding mode)
{
	throw;
}


int Math::Sign(decimal value)
{
	throw;
}


int Math::Sign(double value)
{
	throw;
}


int Math::Sign(float value)
{
	throw;
}


int Math::Sign(int value)
{
	throw;
}


int Math::Sign(long value)
{
	throw;
}


int Math::Sign(sbyte value)
{
	throw;
}


int Math::Sign(short value)
{
	throw;
}


double Math::Sin(double a)
{
	return sin(a);
}


double Math::Sinh(double value)
{
	return sinh(value);
}


double Math::Sqrt(double d)
{
	return sqrt(d);
}


double Math::Tan(double a)
{
	return tan(a);
}


double Math::Tanh(double value)
{
	return tanh(value);
}


decimal Math::Truncate(decimal d)
{
	throw;
}


double Math::Truncate(double d)
{
	throw;
}

